home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / tabdlg2.zip / SRC / TABDLG.C < prev    next >
C/C++ Source or Header  |  1994-05-17  |  23KB  |  1,098 lines
  1. /*
  2. ** TabDlg DLL
  3. ** Copyright (c) 1994 Edward McCreary.
  4. ** All rights reserved.
  5. **
  6. ** Redistribution and use in source and binary forms are freely permitted
  7. ** provided that the above copyright notice and attibution and date of work
  8. ** and this paragraph are duplicated in all such forms.
  9. ** THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
  10. ** IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  11. ** WARRANTIES OF MERCHANTIBILILTY AND FITNESS FOR A PARTICULAR PURPOSE.
  12. */
  13.  
  14. #define STRICT
  15. #include <windows.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #include "tabdlg2.h"
  19. #include "common.h"
  20. #include "dyndlg.h"
  21.  
  22. static HINSTANCE hInst;    /* instance handle of the dll */
  23.  
  24. /*
  25. ** store tab data here, 
  26. ** referenced by dialog handle
  27. */
  28. static FRAME_ENTRY entries[MAX_ENTRY];                                        
  29.  
  30. static int nNextEntry = 0;     /* next empty entry */
  31.  
  32. /* height of tab */
  33. #define TAB_HEIGHT  20
  34.  
  35. /* pens used to draw with */
  36. static  HPEN pens[3];
  37.  
  38. #define PEN_BLACK  0
  39. #define PEN_WHITE  1
  40. #define PEN_SHADOW 2 
  41.  
  42. /* font used for depressed tabs */
  43. HFONT hFont = NULL;
  44.  
  45. /*
  46. ** 
  47. ** Library Entry point
  48. **
  49. */
  50. BOOL WINAPI LibMain (HINSTANCE hInstance, WORD wDataSeg,
  51.        WORD wHeapSize, LPSTR lpszCmdLine)
  52. {
  53.  if(wHeapSize != 0)
  54.   UnlockData(0);
  55.  
  56.  /* store off dll instance handle */
  57.  hInst = hInstance;
  58.  
  59.  /* to keep the compiler from bitching */
  60.  wDataSeg = wDataSeg;
  61.  lpszCmdLine = lpszCmdLine;
  62.  
  63.  return TRUE;
  64. }
  65.  
  66. /*
  67. ** 
  68. ** Lookup tab structure by id of tab
  69. **
  70. */
  71. TAB_ENTRY __export *GetTabEntry(FRAME_ENTRY *pFrame,int nTabID)
  72. {
  73.  TAB_ENTRY *ptr;
  74.  
  75.  /* get list of tabs in this frame */
  76.  ptr = pFrame->tab_list;
  77.  
  78.  /* while not end of list */
  79.  while(ptr)
  80.  {
  81.   if(ptr->nTabID == nTabID) /* if id's match, return pointer to tab */
  82.    return ptr;
  83.   
  84.   /* walk down list */
  85.   ptr = ptr->next; 
  86.  }
  87.  
  88.  /* return null if tab not found */
  89.  return NULL;
  90. } 
  91.  
  92. /*
  93. ** 
  94. ** Lookup internal structure of frame given dialog handle
  95. **
  96. */
  97. FRAME_ENTRY __export *GetFrameEntry(HWND hDlg)
  98. {
  99.  static HWND hDlgCache = NULL;
  100.  static FRAME_ENTRY *pFrameCache = NULL; 
  101.  FRAME_ENTRY *pFrame = NULL;
  102.  int i;
  103.  
  104.  /* if cached */
  105.  if(hDlg == hDlgCache)
  106.   return pFrameCache;
  107.  
  108.  for(i = 0; i < nNextEntry; i++)
  109.   if(entries[i].hDlg == hDlg)
  110.   {
  111.     pFrame = &entries[i];
  112.     break;
  113.   }
  114.  hDlgCache = hDlg;
  115.  pFrameCache = pFrame;  
  116.  return pFrame;
  117. }
  118.  
  119. /*
  120. ** 
  121. ** Set tab nTabID to be the top tab
  122. **
  123. */
  124. BOOL WINAPI __export SetTopTab(HWND hDlg, int nTabID)
  125. {
  126.  FRAME_ENTRY *pFrame;
  127.  TAB_ENTRY   *pTab;
  128.  TAB_CTL     *pControl;
  129.  UINT        uFlags;
  130.  
  131.  /* get data for this frame */
  132.  pFrame = GetFrameEntry(hDlg);
  133.  
  134.  /* abort if not found */
  135.  if(!pFrame)
  136.   return FALSE;
  137.  
  138.  /* save id of new top tab */
  139.  pFrame->nTopTab = nTabID;
  140.  
  141.  /* common flags */
  142.  uFlags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOSIZE | 
  143.     SWP_NOZORDER; 
  144.  
  145.  /* get pointer to list of tabs */   
  146.  pTab = pFrame->tab_list;
  147.  
  148.  /*
  149.  **
  150.  ** loop through list, hide or show each one, then do an invalidate rect 
  151.  ** and updatewindow to force repaint.  this is cleaner than using ShowWindow
  152.  ** for each control.
  153.  **
  154.  */
  155.  
  156.  /* while not at end of list */
  157.  while(pTab)
  158.  {
  159.   pControl = pTab->controls;   /* get pointer to list controls in this tab */
  160.   /* while not at end of list */
  161.   while(pControl) 
  162.   {
  163.    if(pTab->nTabID == nTabID)   /* if new top tab, show control */                       
  164.      SetWindowPos(GetDlgItem(pFrame->hDlg,pControl->wID),NULL,0,0,0,0,
  165.         uFlags | SWP_SHOWWINDOW);
  166.    else                         /* else hide him */
  167.      SetWindowPos(GetDlgItem(pFrame->hDlg,pControl->wID),NULL,0,0,0,0,
  168.         uFlags | SWP_HIDEWINDOW);
  169.    
  170.    /* get next control in list */
  171.    pControl = pControl->next;
  172.   }  
  173.   /* get next tab in list */
  174.   pTab = pTab->next;
  175.  } 
  176.  return TRUE;
  177. }
  178.  
  179. /*
  180. ** 
  181. ** get id of last tab in the frame list
  182. **
  183. */
  184. int __export GetLastTab(FRAME_ENTRY *pFrame)
  185. {
  186.  TAB_ENTRY *pTab;
  187.  
  188.  /* get point to list of tabs */
  189.  if(pFrame->tab_list)
  190.  {
  191.   /* walk to the end of the list */
  192.   pTab = pFrame->tab_list;
  193.   while(pTab->next)
  194.    pTab = pTab->next;
  195.   
  196.   /* return id */ 
  197.   return pTab->nTabID; 
  198.  }
  199.  /* return -1 if failed */
  200.  return -1;
  201. }
  202.  
  203. /*
  204. ** 
  205. ** detect if mouse hit a tab
  206. **
  207. */
  208. int TabHit(HWND hDlg,WORD x, WORD y)
  209. {
  210.  FRAME_ENTRY *pFrame;
  211.  TAB_ENTRY   *pTab;
  212.  int nWidth;
  213.  POINT  pt;
  214.  RECT   rc;
  215.  int    nFrameLeft; 
  216.  
  217.  /* get frame data for this dialog box */
  218.  pFrame = GetFrameEntry(hDlg);
  219.  
  220.  /* abort if not found */
  221.  if(!pFrame)
  222.   return -1;
  223.  
  224.  /* get rectangle of frame control */
  225.  GetWindowRect(pFrame->hWnd,&rc);
  226.  
  227.  /* convert to client coordinates (dialog client) */
  228.  pt.x = rc.left;
  229.  pt.y = rc.top;
  230.  ScreenToClient(pFrame->hDlg,&pt);
  231.  
  232.  /* bottom of hit rectangle is top of frame control */
  233.  rc.bottom = pt.y;
  234.  
  235.  /* top is TAB_HEIGHT above bottom */
  236.  rc.top = rc.bottom - TAB_HEIGHT; 
  237.  
  238.  /* store left edge of the frame */
  239.  rc.left = nFrameLeft = pt.x;
  240.  
  241.  pt.x = rc.right;
  242.  pt.y = rc.bottom;
  243.  ScreenToClient(pFrame->hDlg,&pt);
  244.  rc.right = pt.x;
  245.  
  246.  /* store point where mouse clicked */
  247.  pt.x = x;
  248.  pt.y = y;
  249.  
  250.  /* quick test, if not in rectangle above frame, no sense trying the
  251.  ** others
  252.  */
  253.  if(!PtInRect(&rc,pt))
  254.   return -1;
  255.    
  256.  /* get the width of one tab */
  257.  nWidth = GetTabWidth(pFrame);
  258.  
  259.  /* get pointer to list of tabs */
  260.  pTab = pFrame->tab_list;
  261.  
  262.  /* while not end of list */
  263.  while(pTab)
  264.  {
  265.   /* calc left edge of this tab */
  266.   rc.left = nFrameLeft + pTab->nTabID*nWidth;
  267.   
  268.   /* right edge is simple nWidth over from left edge */
  269.   rc.right = rc.left + nWidth;
  270.   
  271.   /* if hit, return id */
  272.   if(PtInRect(&rc,pt))
  273.    return pTab->nTabID;
  274.   
  275.   /* get next tab in list */
  276.   pTab = pTab->next;
  277.  } 
  278.  
  279.  /* return -1 if none hit */
  280.  return -1;
  281. }
  282.  
  283. /*
  284. ** 
  285. ** find the width of a tab
  286. **
  287. */
  288. int GetTabWidth(FRAME_ENTRY *pFrame)
  289. {
  290.  int    nNumTabs;
  291.  int    nWidth;
  292.  RECT   rc;
  293.  
  294.  /* if only one tab, don't want it to extend the
  295.  ** entire length, use 2 instead
  296.  */
  297.  nNumTabs = (pFrame->nNextTab < 2?2:pFrame->nNextTab);
  298.  /* get rectange of frame control */
  299.  GetWindowRect(pFrame->hWnd,&rc);
  300.  
  301.  /* width of a tab is width of frame divided by the number of tabs */
  302.  nWidth = (rc.right - rc.left)/nNumTabs;
  303.  
  304.  return nWidth;
  305. }
  306.  
  307. /*
  308. ** 
  309. ** First time registration
  310. **
  311. */
  312. void __export RegisterLibrary(void)
  313. {
  314.  LOGFONT logfont;
  315.  
  316.  /* store handles to pens used to draw tabs */
  317.  pens[PEN_BLACK] = (HPEN)GetStockObject(BLACK_PEN);
  318.  pens[PEN_WHITE] = (HPEN)GetStockObject(WHITE_PEN);
  319.  pens[PEN_SHADOW] = CreatePen(PS_SOLID,1,GetSysColor(COLOR_BTNSHADOW));
  320.  
  321.  /* create font used to draw depressed tab titles */
  322.  memset(&logfont,0,sizeof(LOGFONT));
  323.  logfont.lfHeight = -13; 
  324.  logfont.lfWeight = FW_NORMAL; 
  325.  lstrcpy(logfont.lfFaceName,"Arial");
  326.  
  327.  hFont = CreateFontIndirect(&logfont); 
  328.  /* if unable to create font, just use system font */
  329.  if(!hFont)
  330.   hFont = (HFONT)GetStockObject(SYSTEM_FONT);
  331. }
  332.  
  333. /*
  334. ** 
  335. ** Remove frame from list and free associated resources
  336. **
  337. */
  338. void __export UnRegisterFrame(HWND hWnd)
  339. {
  340.  int i,j;
  341.  TAB_ENTRY *ptr;
  342.  TAB_ENTRY *ptr_next;
  343.  
  344.  FRAME_ENTRY *pFrame = NULL;
  345.  
  346.  /* walk list of frames, find this one */
  347.  for(i = 0; i < nNextEntry; i++)
  348.   if(entries[i].hWnd == hWnd)
  349.   {
  350.    pFrame = &entries[i];
  351.    break;
  352.   } 
  353.  
  354.  /* if not found, abort */
  355.  if(!pFrame)
  356.   return;
  357.  
  358.  /* restore original window proc for frame */ 
  359.  SetWindowLong(hWnd,GWL_WNDPROC,
  360.   (DWORD)entries[i].OldWndProc);
  361.  
  362.  /* restore original window proc for dialog */
  363.  SetWindowLong(entries[i].hDlg,GWL_WNDPROC,
  364.   (DWORD)entries[i].OldDlgProc);
  365.  
  366.  /* walk list of tabs and free memory for each */
  367.  ptr = pFrame->tab_list;
  368.  while(ptr)
  369.  {
  370.   ptr_next = ptr->next;  
  371.   FreeTab(ptr);
  372.   ptr = ptr_next;  
  373.  }
  374.  
  375.  /* slide all entries above this one down one notch in list */
  376.  for(j = i; j < MAX_ENTRY; j++)
  377.   entries[j] = entries[j+1];
  378.   
  379.  /* decrement entry counter */
  380.  nNextEntry--;
  381.  
  382.  /* if none currently registered, free global resources */
  383.  if(nNextEntry == 0)
  384.   UnRegisterLibrary();
  385. }
  386.  
  387. /*
  388. ** 
  389. ** free up memory used with tab
  390. **
  391. */
  392. void FreeTab(TAB_ENTRY *pTab)
  393. {
  394.  TAB_CTL *ptr;
  395.  TAB_CTL *ptr_next;
  396.  
  397.  /* free memory used to store title */
  398.  free((void *)pTab->name);
  399.  
  400.  /* walk list of controls and free memory assoc. with each */
  401.  ptr = pTab->controls;
  402.  while(ptr)
  403.   {
  404.    ptr_next = ptr->next;
  405.    free((void *)ptr);
  406.    ptr = ptr_next;
  407.   }
  408.  
  409.  /* free tab memory */ 
  410.  free((void *)pTab);
  411. }
  412.  
  413. /*
  414. ** 
  415. ** last time deregistration
  416. **
  417. */
  418. void __export UnRegisterLibrary(void)
  419. {
  420.  DeleteObject(pens[PEN_SHADOW]);
  421.  DeleteObject(hFont);
  422. }
  423.  
  424. /*
  425. ** 
  426. ** force repaint of tabs
  427. **
  428. */
  429. void UpdateTabs(HWND hDlg)
  430. {
  431.  InvalidateRect(hDlg,NULL,TRUE);
  432.  UpdateWindow(hDlg);
  433. }
  434.  
  435. /*
  436. ** 
  437. ** paint the frame control
  438. **
  439. */
  440. void __export PaintFrame(FRAME_ENTRY *pFrame)
  441. {
  442.  RECT   rc;
  443.  POINT  pt[4];
  444.  HPEN   hOldPen;
  445.  HDC    hdc;
  446.  
  447.  /* get rect of frame control */
  448.  GetWindowRect(pFrame->hWnd,&rc);
  449.  
  450.  /* convert to client coordinates of dialog box */
  451.  pt[0].x = rc.left;
  452.  pt[0].y = rc.top;
  453.  ScreenToClient(pFrame->hDlg,&pt[0]);
  454.  rc.left = pt[0].x;
  455.  rc.top = pt[0].y;
  456.  
  457.  pt[0].x = rc.right;
  458.  pt[0].y = rc.bottom;
  459.  ScreenToClient(pFrame->hDlg,&pt[0]);
  460.  rc.right = pt[0].x;
  461.  rc.bottom = pt[0].y;
  462.  
  463.  /* get a dc to the dialog box */
  464.  hdc = GetDC(pFrame->hDlg);
  465.  
  466.  /* now draw the u shaped frame */
  467.  hOldPen = SelectObject(hdc, pens[PEN_BLACK]); 
  468.  // black frame
  469.  pt[0].x = rc.left;
  470.  pt[0].y = rc.top;
  471.  pt[1].x = rc.left;
  472.  pt[1].y = rc.bottom;
  473.  pt[2].x = rc.right;
  474.  pt[2].y = rc.bottom;
  475.  pt[3].x = rc.right;
  476.  pt[3].y = rc.top-1; // make sure they connect
  477.  
  478.  Polyline(hdc,(LPPOINT)&pt,4);
  479.  
  480.  SelectObject(hdc,pens[PEN_WHITE]);
  481.  // two white border lines
  482.  pt[0].x = rc.left+1;
  483.  pt[0].y = rc.top;
  484.  pt[1].x = rc.left+1;
  485.  pt[1].y = rc.bottom-1; 
  486.  
  487.  Polyline(hdc,(LPPOINT)&pt,2);
  488.  
  489.  pt[0].x = rc.left+2;
  490.  pt[0].y = rc.top;
  491.  pt[1].x = rc.left+2;
  492.  pt[1].y = rc.bottom-2;
  493.  Polyline(hdc,(LPPOINT)&pt,2);
  494.  
  495.  SelectObject(hdc,pens[PEN_SHADOW]); 
  496.  // two shadow lines
  497.  pt[0].x = rc.left + 1;
  498.  pt[0].y = rc.bottom - 1;
  499.  pt[1].x = rc.right-1;
  500.  pt[1].y = rc.bottom - 1;
  501.  pt[2].x = rc.right - 1;
  502.  pt[2].y = rc.top - 1;
  503.  
  504.  Polyline(hdc,(LPPOINT)&pt,3);
  505.  
  506.  pt[0].x = rc.left + 2;
  507.  pt[0].y = rc.bottom - 2;
  508.  pt[1].x = rc.right-2;
  509.  pt[1].y = rc.bottom - 2;
  510.  pt[2].x = rc.right - 2;
  511.  pt[2].y = rc.top - 1;
  512.  Polyline(hdc,(LPPOINT)&pt,3);
  513.  
  514.  /* restore old pen */   
  515.  SelectObject(hdc,hOldPen);   
  516.  
  517.  /* paint tabs above the frame */
  518.  PaintTabs(pFrame,hdc,&rc); 
  519.  
  520.  /* give dc back to system */
  521.  ReleaseDC(pFrame->hDlg,hdc); 
  522. }
  523.  
  524. /*
  525. ** 
  526. ** draw the tabs on top of the frame
  527. **
  528. */
  529. void __export PaintTabs(FRAME_ENTRY *pFrame,HDC hdc,LPRECT lprc)
  530. {
  531.  RECT   rcTab;
  532.  int    nWidth; 
  533.  TAB_ENTRY  *pTab;
  534.  int    nFrameLeft;
  535.  int    nLastTab;
  536.  POINT  pt[6];
  537.  HPEN   hOldPen;
  538.  
  539.  /* store left edge of frame */
  540.  nFrameLeft = lprc->left;
  541.  
  542.  /* set top and bottom limits of tabs */
  543.  rcTab.bottom = lprc->top;
  544.  rcTab.top = rcTab.bottom - TAB_HEIGHT; 
  545.  
  546.  /* get width of single tab */
  547.  nWidth = GetTabWidth(pFrame);
  548.  
  549.  /* index of last tab in list */
  550.  nLastTab = GetLastTab(pFrame);
  551.  
  552.  /* paint each tab */
  553.  pTab = pFrame->tab_list;
  554.  while(pTab)
  555.  {
  556.   /* set left and right limits of this tab */
  557.   rcTab.left = nFrameLeft + pTab->nTabID*nWidth;
  558.   rcTab.right = rcTab.left + nWidth;
  559.   
  560.   // if last tab, expand rect to end of frame
  561.   // but not if last tab == first tab
  562.   if(pTab->nTabID != 0 && pTab->nTabID == nLastTab)
  563.    rcTab.right = lprc->right;   
  564.   
  565.   /* if tab is top tab, draw it in up position */ 
  566.   if(pFrame->nTopTab == pTab->nTabID)
  567.   {
  568.    PaintUpTab(hdc,&rcTab);
  569.    DrawTabText(hdc,&rcTab,(LPCSTR)pTab->name,TRUE,pFrame->bUseShadow);
  570.    if(GetFocus() == pFrame->hWnd) 
  571.     DrawFocusRect(hdc,&rcTab);
  572.   
  573.   }
  574.   else
  575.   /* draw in down position */
  576.   {
  577.    PaintDownTab(hdc,&rcTab);
  578.    DrawTabText(hdc,&rcTab,(LPCSTR)pTab->name,FALSE,pFrame->bUseShadow);   
  579.   }  
  580.   /* loop to next tab in list */
  581.   pTab = pTab->next;
  582.  }
  583.  
  584.  /* draw horz lines */ 
  585.  /* this make lower tabs appear below top tab */
  586.  
  587.  /*
  588.  ** if top tab not first in list, draw lines from left edge of
  589.  ** frame to left edge of top tab
  590.  */
  591.  if(pFrame->nTopTab != 0) 
  592.  {
  593.   hOldPen = SelectObject(hdc,pens[PEN_BLACK]);
  594.   pt[0].x = lprc->left+1;
  595.   pt[0].y = lprc->top;
  596.   pt[1].x = pFrame->nTopTab*nWidth + nFrameLeft;
  597.   pt[1].y = lprc->top;
  598.   Polyline(hdc,(LPPOINT)&pt,2); 
  599.   
  600.   SelectObject(hdc,pens[PEN_WHITE]);
  601.   pt[1].x = pFrame->nTopTab*nWidth + nFrameLeft + 3;
  602.   pt[0].y = lprc->top + 1;
  603.   pt[1].y = lprc->top + 1;
  604.   Polyline(hdc,(LPPOINT)&pt,2); 
  605.   pt[0].y = lprc->top + 2;
  606.   pt[1].y = lprc->top + 2;
  607.   Polyline(hdc,(LPPOINT)&pt,2); 
  608.   
  609.   SelectObject(hdc,hOldPen);
  610.  }
  611.  /* if not end of list or if only one tab */ 
  612.  
  613.  /*
  614.  ** draw lines from right edge of last tab to right edge
  615.  ** of frame
  616.  */
  617.  if(pFrame->nTopTab != nLastTab || nLastTab == 0) 
  618.  {
  619.   hOldPen = SelectObject(hdc,pens[PEN_BLACK]);
  620.   pt[0].x = pFrame->nTopTab*nWidth + nFrameLeft + nWidth;
  621.   pt[0].y = lprc->top;
  622.   pt[1].x = lprc->right;
  623.   pt[1].y = lprc->top;
  624.   Polyline(hdc,(LPPOINT)&pt,2); 
  625.   
  626.   SelectObject(hdc,pens[PEN_WHITE]);  
  627.   pt[0].y++;  
  628.   pt[1].y++;
  629.   Polyline(hdc,(LPPOINT)&pt,2); 
  630.  
  631.   pt[0].x--;
  632.   pt[0].y++;
  633.   pt[1].x--;
  634.   pt[1].y++;
  635.   Polyline(hdc,(LPPOINT)&pt,2); 
  636.   
  637.   SelectObject(hdc,pens[PEN_SHADOW]); 
  638.   pt[0].y--;
  639.   pt[1].y = pt[0].y;
  640.   pt[1].x = pt[0].x - 1;
  641.   pt[2].x = pt[1].x;
  642.   pt[2].y = pt[1].y + 2;
  643.   Polyline(hdc,(LPPOINT)&pt,3); 
  644.   
  645.   SelectObject(hdc,hOldPen);
  646.  }
  647. }
  648.  
  649. /*
  650. ** 
  651. ** draw the text in the tab
  652. **
  653. */
  654. void DrawTabText(HDC hdc,LPRECT lprc,LPCSTR text,BOOL bTop, BOOL bShadow)
  655. {
  656.  RECT       rc;
  657.  COLORREF   cwOld;
  658.  HFONT      hOldFont;
  659.  int        nOldBkMode;
  660.  UINT uTextStyle = DT_SINGLELINE | DT_VCENTER | DT_CENTER;
  661.  
  662.  /* let background color show */
  663.  nOldBkMode = SetBkMode(hdc,TRANSPARENT);
  664.  
  665.  /* don't screw up lprc */
  666.  CopyRect(&rc,lprc);
  667.  
  668.  /* to account for borders */
  669.  InflateRect(&rc,-5,-4);
  670.  
  671.  /* shift down and to the right */
  672.  OffsetRect(&rc,1,1);
  673.  
  674.  /* draw white text to give chisled look */
  675.  cwOld = SetTextColor(hdc,RGB(0xFF,0xFF,0xFF)); 
  676.  
  677.  /* use small font for depressed tabs */
  678.  if(!bTop)
  679.   hOldFont = SelectObject(hdc,hFont);
  680.  
  681.  if(bShadow) /* only draw if shadow enabled */
  682.   DrawText(hdc,text,-1,&rc,uTextStyle);
  683.  
  684.  /* shift up and to the right */
  685.  OffsetRect(&rc,-1,-1);
  686.  
  687.  /* use black text */
  688.  SetTextColor(hdc,RGB(0x00,0x00,0x00)); 
  689.  
  690.  DrawText(hdc,text,-1,&rc,uTextStyle); 
  691.  
  692.  /* restore original font if needed */
  693.  if(!bTop)
  694.   SelectObject(hdc,hOldFont);
  695.  
  696.  /* restore old text color */
  697.  SetTextColor(hdc,cwOld);
  698.  
  699.  /* restore old background mode */
  700.  SetBkMode(hdc,nOldBkMode);
  701. }
  702.  
  703. /*
  704. ** 
  705. ** draw a top tab
  706. **
  707. */
  708. void __export PaintUpTab(HDC hdc, LPRECT lprc)
  709. {
  710.  POINT  pt[6];
  711.  HPEN   hOldPen;
  712.  
  713.  /* top tab is just the down tab with some extra lines */
  714.  PaintDownTab(hdc,lprc);
  715.  hOldPen = SelectObject(hdc,pens[PEN_WHITE]);
  716.  
  717.  pt[0].x = lprc->left + 2;
  718.  pt[0].y = lprc->bottom;
  719.  
  720.  pt[1].x = lprc->left + 2;
  721.  pt[1].y = lprc->top + 4;
  722.  
  723.  pt[2].x = lprc->left + 4;
  724.  pt[2].y = lprc->top + 2;
  725.  
  726.  pt[3].x = lprc->right - 4;
  727.  pt[3].y = lprc->top + 2;
  728.  
  729.  Polyline(hdc,(LPPOINT)&pt,4); 
  730.  
  731.  pt[0].x = lprc->left + 3;
  732.  pt[0].y = lprc->top + 4;
  733.  
  734.  pt[1].x = lprc->left + 5;
  735.  pt[1].y = lprc->top + 2;
  736.  
  737.  Polyline(hdc,(LPPOINT)&pt,2); 
  738.    
  739.  SelectObject(hdc,pens[PEN_SHADOW]); 
  740.  
  741.  pt[0].x = lprc->right - 4 ;
  742.  pt[0].y = lprc->top + 2;
  743.  
  744.  pt[1].x = lprc->right - 2;
  745.  pt[1].y = lprc->top + 4;
  746.  
  747.  pt[2].x = lprc->right - 2;
  748.  pt[2].y = lprc->bottom + 1;
  749.  
  750.  Polyline(hdc,(LPPOINT)&pt,3); 
  751.  
  752.  pt[0].x = lprc->right - 4 ;
  753.  pt[0].y = lprc->top + 3;
  754.  
  755.  pt[1].x = lprc->right - 2 ;
  756.  pt[1].y = lprc->top + 5;
  757.  
  758.  Polyline(hdc,(LPPOINT)&pt,2); 
  759.  
  760.  SelectObject(hdc,hOldPen);
  761. }
  762.  
  763. /*
  764. ** 
  765. ** draw a down tab
  766. **
  767. */
  768. void __export PaintDownTab(HDC hdc, LPRECT lprc)
  769. {
  770.  POINT  pt[6];
  771.  HPEN   hOldPen;
  772.  
  773.  hOldPen = SelectObject(hdc,pens[PEN_BLACK]);
  774.  
  775.  pt[0].x = lprc->left;
  776.  pt[0].y = lprc->bottom;
  777.  
  778.  pt[1].x = lprc->left;
  779.  pt[1].y = lprc->top + 4;
  780.  
  781.  pt[2].x = lprc->left + 4;
  782.  pt[2].y = lprc->top;
  783.  
  784.  pt[3].x = lprc->right - 4;
  785.  pt[3].y = lprc->top;
  786.  
  787.  pt[4].x = lprc->right;
  788.  pt[4].y = lprc->top + 4;
  789.  
  790.  pt[5].x = lprc->right;
  791.  pt[5].y = lprc->bottom;
  792.  
  793.  Polyline(hdc,(LPPOINT)&pt,6);
  794.  
  795.  SelectObject(hdc,pens[PEN_WHITE]);
  796.  
  797.  pt[0].x = lprc->left + 1;
  798.  pt[0].y = lprc->bottom;
  799.  
  800.  pt[1].x = lprc->left + 1;
  801.  pt[1].y = lprc->top + 4;
  802.  
  803.  pt[2].x = lprc->left + 4;
  804.  pt[2].y = lprc->top + 1;
  805.  
  806.  pt[3].x = lprc->right - 3;
  807.  pt[3].y = lprc->top + 1;
  808.  
  809.  Polyline(hdc,(LPPOINT)&pt,4);
  810.  
  811.  SelectObject(hdc,pens[PEN_SHADOW]); 
  812.  
  813.  pt[0].x = lprc->right - 3 ;
  814.  pt[0].y = lprc->top + 2;
  815.  
  816.  pt[1].x = lprc->right - 1;
  817.  pt[1].y = lprc->top + 4;
  818.  
  819.  pt[2].x = lprc->right - 1;
  820.  pt[2].y = lprc->bottom + 1;
  821.  
  822.  Polyline(hdc,(LPPOINT)&pt,3);
  823.     
  824.  SelectObject(hdc, hOldPen);
  825. }
  826.  
  827. /*
  828. ** 
  829. ** Subclass proc for frame window
  830. **
  831. */
  832. LONG WINAPI __export FrameWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  833. {
  834.  FRAME_ENTRY *pFrame = NULL;
  835.  
  836.  /* get frame data */
  837.  pFrame = GetFrameEntry(GetParent(hWnd));
  838.  
  839.  /* this frame doesn't have and data so use default proc */
  840.  if(!pFrame)
  841.   return DefWindowProc(hWnd,msg,wParam,lParam);
  842.  
  843.     
  844.  switch(msg)
  845.  {
  846.   case WM_PAINT:
  847.   {   
  848.    PAINTSTRUCT ps;
  849.    
  850.    BeginPaint(hWnd,&ps);
  851.    PaintFrame(pFrame);                      
  852.    EndPaint(hWnd,&ps);   
  853.    return 0L;
  854.   }
  855.   break;
  856.   
  857.   case WM_NCDESTROY:
  858.    /* remove frame data for this window */
  859.    UnRegisterFrame(hWnd);
  860.    return 0L;
  861.  }
  862.  
  863.  /* call original window procedure */
  864.  return CallWindowProc(pFrame->OldWndProc,hWnd,msg,wParam,lParam);
  865. }
  866.  
  867. /*
  868. ** 
  869. ** subclass proc for dialog box
  870. **
  871. */
  872. LONG WINAPI __export DlgWndProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
  873. {
  874.  FRAME_ENTRY *pFrame = NULL;
  875.  
  876.  /* get frame data for this dialog box */
  877.  pFrame = GetFrameEntry(hDlg);
  878.  
  879.  /* if not data found, revert to default dialog proc */    
  880.  if(!pFrame)
  881.   return DefDlgProc(hDlg,msg,wParam,lParam);
  882.     
  883.  switch(msg)
  884.  {
  885.   case WM_LBUTTONDOWN:
  886.   {
  887.    int id;
  888.    
  889.    /* check button click */
  890.    id = TabHit(hDlg,LOWORD(lParam),HIWORD(lParam));
  891.    /* if not -1, then is id of tab clicked on */
  892.    if(id != -1)
  893.     { 
  894.      /* no sense repainting if not neccessary */   
  895.       if(pFrame->nTopTab != id)
  896.       {
  897.        SetTopTab(hDlg,id);
  898.        /* force repaint */
  899.        UpdateTabs(hDlg);    
  900.       }
  901.     }   
  902.   }
  903.   break;
  904.   default:
  905.   break;
  906.  }
  907.  
  908.  /* call original dialog proc */
  909.  return CallWindowProc(pFrame->OldDlgProc,hDlg,msg,wParam,lParam);
  910. } 
  911.  
  912. /*
  913. ** 
  914. ** not much here...
  915. **
  916. */
  917. int WINAPI _WEP(int nSystemExit)
  918. {
  919.  
  920.   return 1;
  921. }
  922.  
  923.  
  924. /*
  925. ** 
  926. ** Build tab control from list of dialog templates
  927. **
  928. */
  929.  
  930. BOOL WINAPI __export BuildTabs(HWND hDlg,HINSTANCE hInst, UINT wFrameID, 
  931.     const TAGTEMPLATE FAR *lpTemplates, int nNumTemplates)
  932. {
  933.  int i;
  934.  HWND       hWnd;
  935.  
  936.  /* if maxed out abort */
  937.  if(nNextEntry == MAX_ENTRY)
  938.   return FALSE;
  939.  
  940.  /* get handle to frame */ 
  941.  hWnd = GetDlgItem(hDlg,wFrameID);
  942.  
  943.  /* store handles */
  944.  entries[nNextEntry].hWnd = hWnd;
  945.  entries[nNextEntry].hDlg = hDlg;
  946.  
  947.  /* first time, define globals */ 
  948.  if(nNextEntry == 0)
  949.   RegisterLibrary();
  950.  
  951.  /* subclass the frame and store old wndproc */
  952.  entries[nNextEntry].OldWndProc = (WNDPROC)SetWindowLong(hWnd,
  953.                 GWL_WNDPROC,(DWORD)FrameWndProc);
  954.  
  955.  /* subclass the dialog and store old wndproc */               
  956.  entries[nNextEntry].OldDlgProc = (WNDPROC)SetWindowLong(hDlg,
  957.                 GWL_WNDPROC,(DWORD)DlgWndProc);
  958.  
  959.  /* clear everything out */
  960.  entries[nNextEntry].tab_list = NULL;
  961.  entries[nNextEntry].nTopTab = 0;
  962.  entries[nNextEntry].nNextTab = 0; 
  963.  entries[nNextEntry].bUseShadow = FALSE;
  964.  
  965.  
  966.  nNextEntry++;
  967.  
  968.  /* for each template create a tab */
  969.  for(i=0;i<nNumTemplates;i++) 
  970.   if(!CreateSingleTab(hDlg,hInst,wFrameID,
  971.     (TAGTEMPLATE FAR *)&lpTemplates[i]))
  972.    return FALSE;
  973.  
  974.  /* set first one on top as default */
  975.  SetTopTab(hDlg,0);
  976.  return TRUE;
  977. }
  978.  
  979. /*
  980. ** 
  981. ** create a single tab from template
  982. **
  983. */
  984.  
  985. BOOL WINAPI CreateSingleTab(HWND hDlg,HINSTANCE hInst, UINT wFrameID, 
  986.     TAGTEMPLATE FAR *lpTemplate)
  987. {
  988.  FRAME_ENTRY *pFrame;
  989.  TAB_ENTRY   *pNewTab;
  990.  
  991.  /* pointer to info for this frame */
  992.  pFrame = GetFrameEntry(hDlg);
  993.  
  994.  /* abort! */
  995.  if(!pFrame)
  996.   return -1;
  997.  
  998.  /* alloc a new tab structure */ 
  999.  pNewTab = (TAB_ENTRY *)malloc(sizeof(TAB_ENTRY));
  1000.  
  1001.  /* abort */
  1002.  if(!pNewTab)
  1003.   return -1;
  1004.  
  1005.  /* alloc room for title and copy over */ 
  1006.  pNewTab->name = (char *)malloc(strlen(lpTemplate->lpTitle)+1);
  1007.  strcpy(pNewTab->name,lpTemplate->lpTitle);
  1008.  
  1009.  /* new tab id and clear out data */
  1010.  pNewTab->nTabID = pFrame->nNextTab++;
  1011.  pNewTab->controls = NULL;
  1012.  pNewTab->next = NULL;
  1013.  
  1014.  /* if tab_list empty, set new tab to first in list */
  1015.  if(pFrame->tab_list == NULL)
  1016.   pFrame->tab_list = pNewTab;
  1017.  else
  1018.  /* append to end of linked list */
  1019.  {
  1020.   TAB_ENTRY *ptr;
  1021.   
  1022.   ptr = pFrame->tab_list;
  1023.   
  1024.   while(ptr->next)
  1025.    ptr = ptr->next;
  1026.    
  1027.   ptr->next = pNewTab; 
  1028.  }
  1029.  
  1030.  /* create controls from template */
  1031.  return MergeControlsIntoDlg(hDlg,wFrameID,hInst,pNewTab,lpTemplate->lpDlgTemplate);
  1032. }
  1033.  
  1034. /*
  1035. ** 
  1036. ** add control to list of controls in pTab
  1037. **
  1038. */
  1039. BOOL WINAPI __export AddControl(TAB_ENTRY *pTab, WORD wControlID)
  1040. {
  1041.  TAB_CTL     *pCtl;
  1042.  
  1043.  if(!pTab)
  1044.   return FALSE;
  1045.  
  1046.  /* alloc new control structure and fill */ 
  1047.  pCtl = (TAB_CTL *)malloc(sizeof(TAB_CTL));
  1048.  
  1049.  /* abort if malloc failed */
  1050.  if(!pCtl)
  1051.   return FALSE;
  1052.  
  1053.  /* save control data */ 
  1054.  pCtl->wID = wControlID;
  1055.  pCtl->next = NULL;
  1056.  
  1057.  /* 
  1058.   * if list empty stick at the head otherwise append to the end
  1059.   * of the list.
  1060.   */
  1061.  if(pTab->controls == NULL)
  1062.   pTab->controls = pCtl;
  1063.  else
  1064.  {
  1065.   TAB_CTL *ptr;
  1066.   
  1067.   ptr = pTab->controls;
  1068.   
  1069.   while(ptr->next)
  1070.    ptr = ptr->next;
  1071.    
  1072.   ptr->next = pCtl; 
  1073.  }
  1074.  return TRUE;
  1075. }
  1076.  
  1077.  
  1078. /*
  1079. ** 
  1080. ** turn on/off shadow in tab's
  1081. **
  1082. */
  1083. void WINAPI __export SetTabStyle(HWND hDlg, DWORD dwStyle)
  1084. {
  1085.  FRAME_ENTRY *pFrame; 
  1086.  /* pointer to info for this frame */
  1087.  pFrame = GetFrameEntry(hDlg);
  1088.  
  1089.  /* abort! */
  1090.  if(!pFrame)
  1091.   return;
  1092.  
  1093.  if(dwStyle & TAB_SHADOWTEXT)
  1094.   pFrame->bUseShadow = TRUE; 
  1095.  else
  1096.   pFrame->bUseShadow = FALSE;
  1097. }
  1098.